import { Component, OnInit, ViewChild, Input } from '@angular/core';
import { FileHelper } from '../../common/helper/file-helper';
import { NzFormatEmitEvent, NzTreeComponent, NzMessageService, NzModalService, NzTreeNode } from 'ng-zorro-antd';
import { ActivatedRoute, Router } from '@angular/router';
import { FileUploadComponent } from 'src/app/components/file-upload/file-upload.component';
import { FileManageService } from 'src/app/services/project/file-manage/file-manage';
import { Utils } from 'src/app/common/helper/util-helper';
@Component({
  selector: 'app-company-data',
  templateUrl: './company-data.component.html',
  styleUrls: ['./company-data.component.scss']
})
export class CompanyDataComponent implements OnInit {
  // @ViewChild('treeCom') treeCom: NzTreeComponent;
  @ViewChild('treeComMove', { static: false }) treeComMove: NzTreeComponent;
  @ViewChild('fileUpload', { static: false }) public FileUpload: FileUploadComponent;
  // tslint:disable-next-line: max-line-length
  public createUserId = JSON.parse(window.localStorage.getItem('project')) ? JSON.parse(window.localStorage.getItem('project')).creatorUserId : '';
  public status = {
    // 页面类型(企业资料/项目资料) 默认 1企业资料 2项目资料
    type: this.routeInfo.snapshot.queryParams['type'] || 2,
    dataList: null,
    name: window.localStorage.getItem('project') ? JSON.parse(window.localStorage.getItem('project')).name : '',
    userId: window.localStorage.getItem('APDInfo') ? JSON.parse(window.localStorage.getItem('APDInfo')).userId : '',
    // 2019年4月20日12:32:21新增
    // 所有文件夹数据
    NodesList: null,
    // 菜单根目录数据
    Menu: [],
    // 所在目录层级数组 默认根为全部文件
    breadcrumbList: [
      {
        name: '全部文件',
        id: ''
      }
    ],
    // 复选框中是否全是文件类型
    isAllfile: true,
    // 选择的菜单
    activedItem: null,
    // 所在文件夹位置
    locationNode: null,
    // 点击时间间隔：
    startTime: null,
    // 前一个选中的数据
    lastNode: null,
    // 树形目录数据
    treeNodes: null,
    // 树形目录数据
    MovetreeNodes: null,
    // 批量删除按钮状态
    delBtnStatus: false,
    // 全选状态
    allChecked: false,
    // 半选状态
    indeterminate: false,
    // 项目ID
    projectId: window.localStorage.getItem('project') ? JSON.parse(window.localStorage.getItem('project')).id : '',
    // 企业ID
    // PrimaryId: Utils.getLocalStorage('organizationUnitId') || '',
    PrimaryId: JSON.parse(window.localStorage.getItem('organizationUnitId')) || '',
    // 预览配置
    preview: {
      isVisible: false,
      title: null,
      data: null,
      width: 1000,
      height: 500,
      url: null
    },
    // 文件树加载样式
    loadingStatus: {
      loadingTip: '加载中',
      isLoading: false
    },
    // 文件分页数据加载样式
    fileloadingStatus: {
      loadingTip: '加载中',
      isLoading: false
    },
    // 新增/编辑弹窗信息
    editModal: {
      // 操作类别
      operationType: 1,
      isVisible: false,
      title: '新增目录',
      label: '目录结构',
      placeholder: '请输入文件夹名称',
      value: null,

      // 当前操作所在节点数据
      data: null,
    },
    // 二维码
    qrCode: {
      isVisible: false,
      title: '查看二维码',
      width: 1000,
      data: null
    },
    // 文件移动弹窗信息
    moveFileModal: {
      isVisible: false,
      title: '文件移动',
      width: 500,
      height: 600,
      // 选中的节点
      activedNode: null,
    },

    // 上传文件信息
    uploadFile: {
      isCreate: false,
      // 上传弹窗状态
      isVisible: false,
      // 上传禁用
      disabledForm: true,
      // 文件上传按钮状态
      uploadBtnStatus: true,
      // 文件对象
      files: null,
      // 文件名
      fileName: '',
      // 大小限制(单位：KB)
      limitFileSize: 500 * 1024,
      // 文件类型限制
      limitFileType: 'text/plain,application/x-msdownload',
      limitFileSuffix: 'exe,txt,msi',
      // 参数Form
      formData: undefined,
      isSubmitFile: false,
      fileQueue: [], percent: 0,
      uploadFileTransfer: null,
      uploadModel: [
        {
          value: null, text: '上传文件', type: 'upload-file', key: 'file-manage', require: true,
          isShowLabel: false, isCreate: false,
          // 指定上传文件类型(无限制)，和上传文件大小限制（单位：兆(M)）
          limitFileType: 'pdf|image|doc|docx|xls|xlsx|mp4|txt|ppt|pptx|zip',
          limitFileSize: 500,
          // limitFileType: 'pdf|image|xls|doc|docx|txt|xlsx',
        },
        { value: '（文件大小请勿超过500M）', type: 'desc', rowType: 'min', isShowLabel: false },
        // { value: '只支持图片格式', type: 'remark', rowType: 'min', isShowLabel: false }
      ]
    },
    // 分页相关数据集合对象
    pager: {
      // 当前页
      pageIndex: 1,
      // 总记录数
      totalCount: 1,
      // 每页显示记录数
      pageSize: 10,
      // 搜索关键字
      filter: ''
    },

    // 排序
    sort: null,
    sortMapping: {
      descend: 'DESC',
      ascend: 'ASC'
    },
    // 包含在全部文件中的节点数
    allTreeNodes: [
      {
        title: '全部文件',
        key: '000',
        expanded: true,
        children: []
      }
    ],
    // 新建前节点树
    beforeInsertNodes: null,
    // 新建文件输入节点信息
    insertNodeInfo: {
      // 是否是新建节点
      isVisible: false,
      value: '新建文件夹',
      parentNode: null,
    },
    // 当前选中的数据集合
    checkedDatas: [],
    // 删除操作所在选中节点
    currentDirNode: null,
    // 选中状态的节点
    activedNode: null,
    // 是否触发文件刷新
    refreshstatus: true,

    // 当前页面所需要的企业权限
    pagePermissions: [

      // 企业文件库
      'APJ.Organizations_DocumentLibrarys.Delete',
      'APJ.Organizations_DocumentLibrarys.Edit',
      'APJ.Organizations_DocumentLibrarys.Move',
      'APJ.Organizations_DocumentLibrarys.NewFolder',
      'APJ.Organizations_DocumentLibrarys.Up'
    ],

    // 所需项目级权限
    PIpagePermissions: [
      // 项目文件库

      // 删除文件
      'APJ.PI.Delete',
      // 移动文件
      'APJ.PI.Move',
      // 新建文件夹
      'APJ.PI.NewFolder',
      // 上传文件
      'APJ.PI.Up',
      // 编辑所有文件
      'APJ.PI.Edit',
    ],
    // 当前页面企业级权限状态
    pageAuthorty: {
      Organizations_DocumentLibrarysDelete: null,
      Organizations_DocumentLibrarysEdit: null,
      Organizations_DocumentLibrarysMove: null,
      Organizations_DocumentLibrarysNewFolder: null,
      Organizations_DocumentLibrarysUp: null
    },
    // 当前页面项目级权限状态
    PIpageAuthorty: {
      PIUp: null,
      PIMove: null,
      PINewFolder: null,
      PIEdit: null,
      PIDelete: null,
    }
  };


  constructor(
    private router: Router,
    private routeInfo: ActivatedRoute,
    public message: NzMessageService,
    public mzModal: NzModalService,
    public fileManageService: FileManageService,
  ) { }



  // 业务代码公共部分+文件列表部分 + 文件目录部分


  ngOnInit() {
    this.init();
    this.getNodesList();
    this.loadData();
    this.loadFloder();
    // this.status.allTreeNodes[0].children = this.status.treeNodes;
  }

  // 初始化权限匹配
  init() {
    if (JSON.parse(window.localStorage.getItem('APDInfo'))['roleCode'] !== 'Admin' && this.status.userId !== this.createUserId) {
      this.status.PIpageAuthorty = Utils.PIgrantedPermissions(
        this.status.PIpagePermissions,
        this.status.PIpageAuthorty,
        true
      )
    } else {
      // admin 角色拥有该页面权限
      // tslint:disable-next-line: forin
      for (let key in this.status.PIpageAuthorty) {
        console.log(key)
        this.status.PIpageAuthorty[key] = true;
      }
    }
    console.log(this.status.PIpageAuthorty)
    this.status.pageAuthorty = Utils.grantedPermissions(
      this.status.pagePermissions,
      this.status.pageAuthorty,
      true
    )
    console.log(this.status.pageAuthorty)
    console.log(this.status.type)
  }



  /*分页搜索相关******************************************************************************** */
  /**
  * 刷新列表
  */
  public refreshDataList() {
    const refresh = this['loadData'].bind(this);
    if (refresh) {
      refresh();
    }
  }

  /**
   * 列表分页
   * @param index <number> 非必填，列表跳转至第几页，默认为当前页(即刷新当前页数据)
   */
  public pageIndexChange(index?: any) {
    // console.log(index)
    const pager = this.status.pager;
    pager.pageIndex = index || pager.pageIndex;
    this.refreshDataList();
  }

  /**
   * 改变每页记录条数
   * @param size <number> 非必填
   */
  public pageSizeChange(size?: number) {
    const pager = this.status.pager;
    pager.pageSize = size || pager.pageSize;
    this.pageIndexChange();
  }


  /**
   * 关键字搜索
   */
  public searchEvent() {
    // 搜索时重置分页
    this.status.pager.pageIndex = 1;
    this.loadData();
  }

  /**
   * 搜索框回车事件
   * @param e <Event>
   */
  public keyupEvent(e: Event) {
    Utils.enter(e, this.searchEvent.bind(this));
  }

  /**
   * 关键字搜索
   */
  public async pageChange(index) {
    this.loadData();
  }

  /**
   * 跳转工作台
   */
  public godashboard() {
    this.router.navigate([`/outer/dashboard`]);
  }

  routeToSurvey() {
    const projectId = JSON.parse(window.localStorage.getItem('project')).id;
    this.router.navigate([`/inner/project/${projectId}/survey`], {queryParams: { info: 'project' }});
  }


  /**
   * 排序
   * @param sort
   */
  public dataSort(sort) {
    this.status.sort = sort.value ? (sort.key + ' ' + this.status.sortMapping[sort.value]) : null;
    // console.info(this.status.sort);
    const childLoadData = this['loadData'];
    if (childLoadData) {
      childLoadData.bind(this)();
    }
  }
  /**********************************************************************************分页搜索相关结束 */

  // 文件列表部分************************************************************************************************************





  /**
   * 列表数据加载
   */
  public loadData() {
    // 刷新数据重置全选、半选状态, 批量删除按钮状态,清空选中项

    this.status.allChecked = false;
    this.status.indeterminate = false;
    this.status.checkedDatas = [];
    // 当前选择的文件夹对象
    // const activeNode = this.status.activedNode;
    const activedItem = this.status.locationNode || this.status.activedItem;
    // console.info(activedItem);
    let parentId = '';
    if (activedItem && activedItem.id) {
      parentId = activedItem.id;
    } else {
      parentId = '00000000-0000-0000-0000-000000000000';
    }
    const params = {
      // 当前目录ID 空显示全部文件
      // parentId: activeNode ? activeNode.key : null ,
      // parentId: activedItem ? activedItem.id : '00000000-0000-0000-0000-000000000000',
      parentId: parentId,
      // 项目ID
      PrimaryId: this.status.type === 2 ? this.status.projectId : this.status.PrimaryId,
      sorting: this.status.sort || '',
      filter: this.status.pager.filter,
      // 每页记录数
      maxResultCount: 1000,
      // 当前页数
      SkipCount: 0,
      // 是否显示文件夹
      showFloder: true,

    };
    this.status.fileloadingStatus.isLoading = true;

    this.fileManageService.QueryPagedList(params).then((res: any) => {
      // console.info(res);
      if (res.success) {
        this.status.dataList = res.result.items || [];
        this.status.pager.totalCount = res.result.totalCount;
      } else {
        this.message.error(Utils.errorMessageProcessor(res) || '数据获取失败');
      }
      this.status.fileloadingStatus.isLoading = false;
    });
  }


  // 选中相关***
  /**
   * 全部选中
   * @param status <any> 全选框的选中状态
   */
  public checkAll(status: any, callBack?: Function) {
    if (this.status.dataList) {
      this.status.dataList.forEach((data: any) => {
        let eachStatus;
        if (callBack) {
          eachStatus = callBack(data);
        }
        if (eachStatus !== false) {
          data['checked'] = status;
        }
      });
      this.refreshCheckboxStatus();
    }
  }


  /**
   * 刷新(所有复选框)状态
   */
  private refreshCheckboxStatus() {
    const dataList = this.status.dataList;
    const allChecked = dataList.filter((value: any) => !value['disabled']).every((value: any) => value['checked'] === true);
    const allUnChecked = dataList.filter((value: any) => !value['disabled']).every((value: any) => !value['checked']);

    this.status.allChecked = allChecked;
    this.status.indeterminate = (!allChecked) && (!allUnChecked);

    // 获取当前选中的数据
    const checkedDatas = [];
    this.status.isAllfile = true;
    dataList.forEach((data) => {
      if (data['checked']) {
        if (!data.fileId) {
          this.status.isAllfile = false;
        }
        checkedDatas.push(data);
      }
    });
    this.status.checkedDatas = checkedDatas;
    // 改变批量操作按钮状态
    this.status.delBtnStatus = !dataList.some((value: any) => value['checked']);
  }

  /**
   * 获取当前选中项
   */
  public getCheckedData() {
    return this.status.checkedDatas;
  }

  /**
   * 文件下载
   * @param data
   */
  public download(data) {
    // console.info(data);
    FileHelper.download(data.name + data.extension, data.url);
  }

  /**
   * 预览文件
   * @param data
   */
  public preview(data: any) {
    const preview = this.status.preview;
    preview.data = data;
    preview.title = data.name;
    preview.url = data.url;
    window.open(preview.url + FileHelper.createPwd(), 'top');
  }


  /**
   * 批量下载
   */
  public batchDownload() {
    // console.info(this.status.checkedDatas)
    if (!this.status.checkedDatas[0]) {
      this.message.warning('请选择文件');
      return;
    }
    // Utils.resetData(this.status.checkedDatas, (item) => {
    //   FileHelper.download(item.name + item.extension, item.url);
    // });
  }

  /**
   * 批量删除
   */
  public batchDelete() {
    if (!this.status.checkedDatas[0]) {
      this.message.warning('请选择文件');
      return;
    }
    this.mzModal.error({
      nzTitle: '删除？',
      nzContent: '<b>确认要删除吗？</b>',
      nzOkText: '确定',
      nzCancelText: '取消',
      nzOkType: 'danger',
      nzOnOk: () => this.OnDatchDeletesave(),
    });

  }


  /**
   * 批量删除确认
   */
  public OnDatchDeletesave() {
    // console.info(this.status.checkedDatas);
    const idGroup = [];
    Utils.resetData(this.status.checkedDatas, (item) => {
      idGroup.push(item.id);
    });
    this.fileManageService.BatchRemove(idGroup).then((res: any) => {
      if (res.success) {
        this.message.success('删除成功');
        // this.status.currentDirNode.remove();
        // this.status.currentDirNode.clearChildren();
        // 删除成功清空已选中
        // this.status.checkedDatas = [];
        this.loadData();
      } else {
        this.message.error(Utils.errorMessageProcessor(res));
      }
    });
  }

  /**
   * 移动文件
   */
  public movefile() {
    if (!this.status.checkedDatas[0]) {
      this.message.warning('请选择文件');
      return;
    }
    this.status.moveFileModal.isVisible = true;
    this.status.MovetreeNodes = this.status.allTreeNodes;
  }

  /**
   * 移动文件保存
   */
  public movefilesave() {
    if (this.status.insertNodeInfo.isVisible) {
      const insertNode = document.getElementById('insertNode');
      setTimeout(() => {
        insertNode.focus();
      }, 0);
      return;
    }
    if (!this.status.moveFileModal.activedNode) {
      this.message.warning('请选择文件夹');
      return;
    }
    // 不能选择全部文件
    if (this.status.moveFileModal.activedNode.key === '000') {
      this.message.warning('请选择其他文件夹');
      return;
    }
    const idGroup = [];
    Utils.resetData(this.status.checkedDatas, (item) => {
      idGroup.push(item.id);
    });
    const params = {
      idList: idGroup,
      parentId: this.status.moveFileModal.activedNode.key,
    };
    this.fileManageService.MoveToFolder(params).then((res: any) => {

      if (res.success) {
        this.message.success('移动成功');
        this.status.moveFileModal.isVisible = false;
        // 移动成功 触发文件夹点击
        const data: any = {};
        const node = this.status.moveFileModal.activedNode;
        data['node'] = node;
        // this.setNodeExpanded(node);
        // this.loadFloder();
        this.loadData();
        // this.activeNode(data);
        // this.clickMenuItem(data);
        // 清空选中的数据
        this.status.moveFileModal.activedNode = null;
        // this.status.checkedDatas = [];
      } else {
        this.message.error(Utils.errorMessageProcessor(res));
      }
    });
  }

  // /**
  //  * 展开所有父节点
  //  * @param node 当前节点
  //  */
  // public setNodeExpanded(node) {
  //   if (node.parentNode) {
  //     console.info('11111')
  //     let parentNode = node.getParentNode();
  //     parentNode['expanded'] = true;
  //     parentNode['isExpanded'] = true;
  //     this.setNodeExpanded(parentNode);
  //   }
  // }

  /**
   * 生成二维码
   */
  public makeQRCode() {
    if (!this.status.checkedDatas[0]) {
      this.message.warning('请选择文件');
      return;
    }
    if (!this.status.isAllfile) {
      this.message.warning('不能选择文件夹');
      return;
    }
    Utils.forEach(this.status.checkedDatas, (item) => {
      item.url = item.url + FileHelper.createPwd();
    });
    // console.log(this.status.checkedDatas)
    this.status.qrCode.data = this.status.checkedDatas;
    this.status.qrCode.isVisible = true;
  }


  /**
   * 文件上传
   */
  public uploadFile() {
    // 当前选择的文件夹对象
    const activedItem = this.status.locationNode || this.status.activedItem;
    // if (!activedItem) {
    //   this.message.warning('请选择文件夹');
    //   // this.status.uploadFile.isVisible = false;
    //   return;
    // }
    this.status.uploadFile.isCreate = true;
    setTimeout(() => {
      this.status.uploadFile.isVisible = true;
      this.status.uploadFile.disabledForm = false;
    }, 0);
  }

  /**
   * 文件上传成功回调
   */
  public uploadFileSuccess(uploadResult) {
    console.info('上传成功');
    this.status.uploadFile.uploadFileTransfer = uploadResult[0];
    // 选择文件后保存并上传
    // this.fileSub();
  }
   /**
   * 文件上传失败回调
   */
  public UploadFileFail(uploadResult) {
    console.info('上传失败');
    this.status.uploadFile.uploadFileTransfer = null;
  }
  /**
   * 文件上传关闭
   */
  public closeUploadFile() {
    this.status.uploadFile.isVisible = false;
    this.status.uploadFile.isCreate = false;
    this.status.uploadFile.uploadFileTransfer = null;
  }

  /**
   * 文件上传提交请求
   */
  public fileSub() {
    // 当前选择的文件夹对象
    const activedItem = this.status.locationNode || this.status.activedItem;
    // 当前上传的文件对象
    const uploadFileTransfer = this.status.uploadFile.uploadFileTransfer;
    let params = null;
    let parentId
    if (activedItem && activedItem.id !== '') {
      parentId = activedItem.id || activedItem.key;
    } else {
      parentId = '00000000-0000-0000-0000-000000000000'
    }
    if (!uploadFileTransfer) {
      this.message.warning('请选择文件');
    } else {
      params = {
        // PrimaryId: this.status.carModelId,
        PrimaryId: this.status.type === 2 ? this.status.projectId : this.status.PrimaryId,
        parentId: parentId,
        fileId: uploadFileTransfer.fileInfo.id,
        name: uploadFileTransfer.name,
        url: uploadFileTransfer.url,
        extension: uploadFileTransfer.type,
        size: uploadFileTransfer.size

      };
      this.fileManageService.CreateFile(params).then((res: any) => {
        // console.info(res)
        if (res.success) {
          this.message.success('上传成功');
          this.status.uploadFile.isVisible = false;
          this.status.uploadFile.isCreate = false;
          this.status.uploadFile.uploadFileTransfer = null;
        } else {
          this.message.error(Utils.errorMessageProcessor(res) || '上传失败');
          this.status.uploadFile.isVisible = false;
          this.status.uploadFile.isCreate = false;
          this.status.uploadFile.uploadFileTransfer = null;
        }
        this.loadData();
      });
    }
  }


  // 文件列表部分结束********************************************************************************************************

  // 文件目录树部分********************************************************************************************************

  // 2019年4月20日11:38:40 新增菜单操作部分
  /**
   * 获取根目录菜单
   */
  public getMenu() {
    // const Nodes = this.status.NodesList || [];
    // const menu = [];
    // if (Nodes.length) {
    //   Nodes.forEach(element => {
    //     if (element.parentId === '00000000-0000-0000-0000-000000000000') {
    //       menu.push(element);
    //     }
    //   });
    // }
    // this.status.Menu = menu;

    this.status.NodesList.forEach(el => {
      el['title'] = el.name;
      el['key'] = el.creationUniversalTime;
      el['icon'] = 'anticon anticon-folder';
    });
    this.status.Menu = this.THArrayToTree(this.status.NodesList);
    this.addIsLeaf(this.status.Menu);
  }

  public addIsLeaf(data){
    data.forEach(element => {
      if(element.children){
        this.addIsLeaf(element.children);
      }else{
        element['isLeaf'] = true;
      }
    });
  }

  /**
   * 数组通过parentId匹配成树结构
   * @static
   * @param {Array<any>} arr
   * @returns
   * @memberof TreeHelper
   */
  public THArrayToTree(arr: Array<any>) {
    let map = {};
    arr.forEach(function (item) {
      // 删除所有 children,以防止多次调用
      delete item.children;
      // 将数据存储为 以 id 为 KEY 的 map 索引数据列
      // map是有索引的
      map[item.id] = item;
    });
    let node = [];
    arr.forEach(function (item) {
      // 以当前遍历项，的pid,去map对象中找到索引的id 
      let parent = map[item.parentId];
      // 如果找到索引，那么说明此项不在顶级当中,那么需要把此项添加到，他对应的父级中
      if (parent) {
        (parent.children || (parent.children = [])).push(item);
      } else {
        //如果没有在map中找到对应的索引ID,那么直接把 当前的item添加到 arr结果集中，作为顶级
        node.push(item);
      }
    });
    return node;
  }

  nzEvent(event: NzFormatEmitEvent): void {
    console.log(event);
  }

  /**
   * 获取所有文件夹数据数组
   */
  public getNodesList() {
    const params = {
      // PrimaryId: this.status.type === 2 ? this.status.projectId : this.status.PrimaryId,
      PrimaryId: this.status.type === 2 ? this.status.projectId : this.status.PrimaryId,
      // 每页记录数
      maxResultCount: 1000,
      skipCount: 0,
      filter: '',
      // 是否显示文件夹
      showFloder: true
    };
    this.status.loadingStatus.isLoading = true;
    this.fileManageService.QueryFloderPagedList(params).then((res: any) => {
      // console.log('文件夹目录')
      // console.info(res)
      if (res.success) {
        this.status.NodesList = res.result.items;
        this.getMenu();
      } else {
        this.message.error(Utils.errorMessageProcessor(res) || '获取失败');
      }
    });
  }

  /**
   * 获取文件夹目录分页数据
   */
  public showAllFiles() {
    this.status.activedItem = null;
    this.status.breadcrumbList = [{ name: '全部文件', id: '' }];
    this.status.locationNode = null;
    this.loadData();
    this.status.Menu.forEach(element => {
      element['selected'] = false;
    });
  }

  /**
   * 菜单点击事件
   */
  public clickMenuItem(item) {
    // add
    item = item.node.origin;

    this.status.locationNode = null;
    if (this.status.breadcrumbList.length) {
      this.status.breadcrumbList = [];
    }
    if (!this.status.activedItem || this.status.activedItem !== item) {
      this.status.activedItem = item;
      this.status.Menu.forEach(element => {
        element['selected'] = false;
      });
      item['selected'] = !item['selected'];
      this.status.breadcrumbList.push(item);
    } else {
      this.status.activedItem = null;
      item['selected'] = !item['selected'];
      // 取消选中状态显示全部文件
      const all = { name: '全部文件', id: '' };
      this.status.breadcrumbList.push(all);
    }
    // 编辑、删除按钮不触发此点击事件
    if (this.status.refreshstatus) {
      // 重置分页
      this.status.pager.pageIndex = 1;
      this.loadData();
    }
  }

  /**
   * 返回上级目录
   */
  public goback() {
    if (this.status.breadcrumbList.length > 1) {
      this.status.breadcrumbList.pop();
      const lastOne = this.status.breadcrumbList.pop();
      this.status.breadcrumbList.push(lastOne);
      this.status.locationNode = lastOne;
      // 重置分页
      this.status.pager.pageIndex = 1;
      this.loadData();
      // console.info(this.status.locationNode);

    } else {
      this.message.warning('已是根目录');
    }
  }

  /**
   * 跳转指定目录
   */
  public gothere(item) {
    const len = this.status.breadcrumbList.length;
    let i = 0;
    for (i; i < len; i++) {
      // 回退
      this.status.locationNode = this.status.breadcrumbList.pop();
      // 跳出循环刷新页面
      if (item === this.status.locationNode) {
        this.status.breadcrumbList.push(item);
        this.loadData();
        break;
      }
    }
  }

  /**
   * 双击事件(间隔小于300ms)
   */
  public doubleClick(data) {
    // 防止重复触发
    if (data === this.status.breadcrumbList[this.status.breadcrumbList.length - 1]) {
      console.info('点击跟双击同时触发了');
      return;
    }
    // 双击且间隔小于300ms
    console.info('双击间隔小于300毫秒');
    if (data.fileId) {
      // 文件直接预览
      this.preview(data);
    } else {
      this.status.locationNode = data;
      this.status.breadcrumbList.push(data);
      // 防止跨文件夹选取
      // this.status.checkedDatas = [];
      // 重置分页
      this.status.pager.pageIndex = 1;
      this.loadData();
    }
  }

  /**
   * 点击事件
   * 单击选中 双击重新获取页面数据(间隔小于300ms)
   */
  public chooseData(data) {
    if (this.status.lastNode !== data) {
      this.status.startTime = null;
    }
    this.status.lastNode = data;
    // 获取当前点击时间
    const nowTime = new Date();
    if (!this.status.startTime) {
      // 首次点击 只进行选中
      this.status.startTime = nowTime;
      // if (data.checked) {
      //   data.checked = false ;
      // } else {
      //   data.checked = true;
      // }
      // this.refreshCheckboxStatus();
    } else {
      const interval = Math.floor((nowTime.getTime() - this.status.startTime.getTime()));
      if (interval > 300) {
        this.status.startTime = nowTime;
        // if (data.checked) {
        //   data.checked = false ;
        // } else {
        //   data.checked = true;
        // }
        // this.refreshCheckboxStatus();
      } else {
        // 刷新数据重置全选、半选状态
        this.status.allChecked = false;
        this.status.indeterminate = false;
        this.doubleClick(data);
      }
    }
    // console.info(data)
  }

  /**
   * 抵消复选框自带选中
   */
  public clearclick(data) {
    // if (data.checked) {
    //   data.checked = false ;
    // } else {
    //   data.checked = true;
    // }
  }


  /**
   * 获取文件夹目录分页数据
   */
  public loadFloder() {

    // 刷新文件夹 刷新文件分页数据
    // this.status.activedNode = null;
    // 移动文件点击不刷新文件列表
    // if (this.status.moveFileModal.isVisible === false) {
    //   this.loadData();
    // }
    const params = {
      // PrimaryId: this.status.type === 2 ? this.status.projectId : this.status.PrimaryId,
      PrimaryId: this.status.type === 2 ? this.status.projectId : this.status.PrimaryId,
      // 每页记录数
      maxResultCount: 1000,
      skipCount: 0,
      filter: '',
      // 是否显示文件夹
      showFloder: true
    };
    this.status.loadingStatus.isLoading = true;
    this.fileManageService.QueryFloderPagedList(params).then((res: any) => {
      // console.info(res)
      if (res.success) {
        const treeNodes = res.result.items;
        if (treeNodes.length) {
          // 用于保存所有节点对象，以节点id作为key，以便直接查找子节点
          this.renderTreeNodeToTree(treeNodes);
        } else {
          this.status.loadingStatus.isLoading = false;
        }
      } else {
        this.message.error(Utils.errorMessageProcessor(res) || '文件目录分页获取失败');
      }
      // 刷新树
      // this.treeEdit.refreshTreeNode(res.success, res);
    });
  }

  /**
   * 将数组组合为树形数据结构
   * @param treeNodes 需要转换的数组对象
   */
  private renderTreeNodeToTree(treeNodes, callBack?) {
    if (typeof (treeNodes) === 'function') {
      callBack = treeNodes;
      treeNodes = undefined;
    }
    treeNodes = treeNodes || null;
    const treeNodeAll = {};
    let lastCallBack;
    Utils.asyncEach(treeNodes, (dataItem, idx) => {
      if (callBack) {
        const cbResult = callBack(dataItem, idx);
        if (cbResult === false) {
          return;
        } else if (typeof (cbResult) === 'function' && !lastCallBack) {
          lastCallBack = cbResult;
        }
      }
      dataItem.isLeaf = true;
      dataItem.title = dataItem.name;
      dataItem.key = dataItem.id;
      treeNodeAll[dataItem.id] = dataItem;
    }, () => {
      // this.status.treeNodes = Utils.renderTreeNode(treeNodeAll);
      // this.status.allTreeNodes[0].children = this.status.treeNodes;
      this.status.allTreeNodes[0].children = Utils.renderTreeNode(treeNodeAll);
      this.status.MovetreeNodes = this.status.allTreeNodes;
      // console.log(treeNodeAll)
      // console.info(this.status.MovetreeNodes);
      if (lastCallBack) {
        lastCallBack();
      }
    });
    this.status.loadingStatus.isLoading = false;
  }


  /**
   * 文件夹点击事件
   */
  public openFolder(data: NzTreeNode): void {
    // 叶子节点、已经打开的非选中节点 不触发事件
    if (data.isLeaf || (this.status.moveFileModal.activedNode !== data && data.isExpanded === true)) {
      data.isExpanded = !data.isExpanded;
    }
    data.isExpanded = !data.isExpanded;
  }


  /**
   * 新建文件夹
   */
  public insertNode() {
    if (this.status.insertNodeInfo.isVisible) {
      const insertNode = document.getElementById('insertNode');
      setTimeout(() => {
        insertNode.focus();
      }, 0);
      return;
    }
    this.status.insertNodeInfo.isVisible = true;
    // 判断插入位置
    const activedNode = this.status.moveFileModal.activedNode;

    if (activedNode) {
      // 保存父节点
      this.status.insertNodeInfo.parentNode = activedNode;
      // 在当前选中节点下添加
      // 展开(显示新增的子节点)
      activedNode['expanded'] = true;
      activedNode['isExpanded'] = true;
      // 因为添加了子节点，isLeaf设置为false(是否为最后一个节点：false)
      activedNode['isLeaf'] = false;
      const nodeData = { title: '新建文件夹', key: '', isLeaf: true };
      // 添加子节点
      activedNode.addChildren([nodeData]);
      // 聚焦
      setTimeout(() => {
        let insertNode = document.getElementById('insertNode');
        insertNode.focus();
        insertNode = null;
      }, 0);
    } else {
      this.message.warning('请选择文件夹');
      this.status.insertNodeInfo.isVisible = false;
      return;
    }

  }

  /**
   * 新建文件夹保存
   */
  public insertSave(node) {
    const parentNode = this.status.insertNodeInfo.parentNode;
    // console.info(parentNode);
    node.title = this.status.insertNodeInfo.value;
    const params = {
      PrimaryId: this.status.type === 2 ? this.status.projectId : this.status.PrimaryId,
      name: this.status.insertNodeInfo.value,
    };
    if (parentNode && parentNode.key !== '000') {
      params['parentId'] = parentNode.key;
    }
    // console.info(params)
    this.fileManageService.createFolder(params).then((res: any) => {
      if (res.success) {
        // console.info(res.result);
        if (res.result) {
          node.key = res.result;
        }
        this.message.success('创建成功');
        // 刷新
      } else {
        this.message.error(Utils.errorMessageProcessor(res));
      }
      // 重置数据
      this.status.insertNodeInfo.value = '新建文件夹';
      this.status.insertNodeInfo.parentNode = null;
    });
    // 保存后重启新建文件夹事件
    this.status.insertNodeInfo.isVisible = false;
  }

  /**
   * 新建文件夹取消
   */
  public insertsCancel(node) {
    // 取消后重启新建文件夹事件
    this.status.insertNodeInfo.isVisible = false;
    this.closeMoveFileModal();
  }

  /**
   * 文件移动弹窗关闭
   */
  closeMoveFileModal() {
    this.status.moveFileModal.isVisible = false;
    // 清空缓存
    this.status.moveFileModal.activedNode = null;
    this.status.MovetreeNodes = null;
    this.status.insertNodeInfo.isVisible = false;
    this.status.insertNodeInfo.parentNode = null;
    this.status.insertNodeInfo.value = '新建文件夹';
    this.loadFloder();
    // this.loadData();
  }


  /**
   * 当前树节点点击事件
   */
  public activeNode(data: NzFormatEmitEvent): void {
    // 文件移动弹窗打开时
    // 2019年4月20日17:32:34 只保留文件移动树
    // if (this.status.moveFileModal.isVisible === true) {
    // console.info(data)
    const result = this.clearActiveNode(data);
    if (!result) {
      return;
    }
    data.node.isSelected = true;
    this.status.moveFileModal.activedNode = data.node;
    this.treeComMove.nzTreeService.setSelectedNodeList(this.status.moveFileModal.activedNode);
    // } else {
    //   // 编辑、删除按钮不触发此点击事件
    //   if (this.status.refreshstatus === false) {
    //     return;
    //   }
    //   const result = this.clearActiveNode(data);
    //   // 重置分页
    //   this.status.pager.pageIndex = 1;
    //   // 没有选中任何文件夹
    //   if (!result) {
    //     this.loadData();
    //     return;
    //   }
    //   data.node.isSelected = true;
    //   this.status.activedNode = data.node;
    //   // add selectedNodeList
    //   this.treeCom.nzTreeService.setSelectedNodeList(this.status.activedNode);
    //   this.loadData();
    // }
  }

  public clearActiveNode(data) {
    // 文件移动弹窗打开时
    // 2019年4月20日17:32:34 只保留文件移动树
    // if (this.status.moveFileModal.isVisible === true) {
    let result = true;
    // 如果已经选中则清除选中状态
    if (this.status.moveFileModal.activedNode) {
      result = !(this.status.moveFileModal.activedNode.key === data.node.key);
      this.treeComMove.nzTreeService.setSelectedNodeList(this.status.moveFileModal.activedNode);
      this.status.moveFileModal.activedNode.isSelected = false;
      this.status.moveFileModal.activedNode = null;
    }
    return result;
    // } else {
    //   let result = true;
    //   // 如果已经选中则清除选中状态
    //   if (this.status.activedNode) {
    //     result = !(this.status.activedNode.key === data.node.key);
    //     this.treeCom.nzTreeService.setSelectedNodeList(this.status.activedNode);
    //     this.status.activedNode.isSelected = false;
    //     this.status.activedNode = null;
    //   }
    // return result;
    // }
  }

  /**
   * 关闭弹窗 清除数据
   * @param Modal 需要关闭的弹窗
   */
  public closeModal(Modal) {
    Modal.isVisible = false;
    Modal.data = null;
    this.status.refreshstatus = true;
  }

  /**
   * 编辑点击事件 树形文件夹/文件列表
   * @param node 按钮所在节点
   * @param editType 编辑弹窗类型 树状编辑为1，文件列表为2，新建文件夹为3(新增4只创建根目录)
   */
  public editCatalog(editType, node?) {
    this.status.refreshstatus = false;
    this.status.editModal.data = node;
    this.status.editModal.operationType = editType;
    this.status.editModal.value = node ? node.name : null;
    if (editType === 1 || editType === 3 || editType === 4) {
      this.status.editModal.title = node ? '编辑目录' : '新建目录';
      // this.status.editModal.value = node ? node.name : null;
      this.status.editModal.label = '目录结构';
      this.status.editModal.placeholder = '请输入文件夹名称';
    } else {
      this.status.editModal.title = '编辑';
      // this.status.editModal.value = node.name || null;
      this.status.editModal.label = '名称：';
      this.status.editModal.placeholder = '请输入名称';
    }
    this.status.editModal.isVisible = true;
    const inputNode = document.getElementById('editModal');
    setTimeout(() => {
      inputNode.focus();
      // console.info(this.status.editModal.operationType);
    }, 10);
    // console.info(node)
    // console.info(this.status.activedNode)
  }

  /**
   * 删除点击事件 树形文件夹/文件列表
   * @param node 按钮所在节点
   * @param deleteType 删除弹窗类型 树状为1，文件列表为2
   */
  public deleteCatalog(node) {
    this.status.refreshstatus = false;
    this.status.currentDirNode = node;
    console.info(node)
    this.mzModal.error({
      nzTitle: '删除？',
      nzContent: '<b>确认要删除吗？</b>',
      nzOkText: '确定',
      nzCancelText: '取消',
      nzOkType: 'danger',
      nzOnOk: () => this.onDeleteSave(),
      nzOnCancel: () => this.status.refreshstatus = true
    });
  }


  /**
   * 编辑保存
   * @param editType 编辑弹窗类型 树状编辑为1，文件列表为2，文件夹新建为3
   */
  public onEditSave(editType) {

    // console.info(this.status.editModal.data)
    // const parentNode = this.status.activedNode;
    const parentNode = this.status.locationNode || this.status.activedItem;
    const node = this.status.editModal.data;
    if (!this.status.editModal.value) {
      this.message.warning('请输入文件夹名称');
      const inputNode = document.getElementById('editModal');
      setTimeout(() => {
        inputNode.focus();
        // console.info(this.status.editModal.operationType)
      }, 10);
      return;
    }
    // 创建文件夹 4只创建根目录
    if (editType === 3 || editType === 4) {
      const params = {
        PrimaryId: this.status.type === 2 ? this.status.projectId : this.status.PrimaryId,
        name: this.status.editModal.value,
      };
      if (parentNode && editType !== 4) {
        params['parentId'] = parentNode.id || parentNode.key;
      }
      // console.info(params)
      this.fileManageService.createFolder(params).then((res: any) => {
        if (res.success) {
          // console.info(res.result)
          this.message.success('创建成功');
          // 2019年4月20日11:33:37 取消树形左边菜单
          // // 判断是否在根目录下渲染
          // const activedNode = this.status.activedNode;
          // if (activedNode) {
          //   // 在当前选中节点下添加
          //   // 展开(显示新增的子节点)
          //   activedNode['expanded'] = true;
          //   activedNode['isExpanded'] = true;
          //   // 因为添加了子节点，isLeaf设置为false(是否为最后一个节点：false)
          //   activedNode['isLeaf'] = false;
          //   const nodeData = { title: params.name, key: res ? res.result : '', isLeaf: true };
          //   // 添加子节点
          //   activedNode.addChildren([nodeData]);
          //   console.log(activedNode)

          // } else {
          //   this.loadFloder();
          // }
          // 刷新左边菜单
          this.getNodesList();
          // 刷新数据
          if (parentNode && editType !== 4) {
            this.loadData();
          }
          // this.loadData();

        } else {
          this.message.error(Utils.errorMessageProcessor(res));
        }
      });
    }
    // 编辑文件夹名称
    if (editType === 1) {
      const params = {
        id: node.id || node.key,
        name: this.status.editModal.value,
      };
      // console.info(params)
      this.fileManageService.Rename(params).then((res: any) => {

        if (res.success) {
          this.message.success('修改成功');
          const data = this.status.editModal.data;
          // data.title = params.name;
          data.name = params.name;
          // 选中数据清空
          this.status.checkedDatas = [];
        } else {
          this.message.error(Utils.errorMessageProcessor(res) || '修改失败');
        }
      });
    }

    // 编辑文件名称
    if (editType === 2) {
      // console.info(node);
      const params = {
        id: node.id,
        name: this.status.editModal.value,
      };
      // console.info(params)
      this.fileManageService.Rename(params).then((res: any) => {

        if (res.success) {
          this.message.success('修改成功');
          const data = this.status.editModal.data;
          data.title = params.name;
        } else {
          this.message.error(Utils.errorMessageProcessor(res) || '修改失败');
        }
        this.loadData();
      });
    }
    this.status.editModal.isVisible = false;
    this.status.refreshstatus = true;
  }

  /**
   * 删除保存
   *
   */
  public onDeleteSave() {
    // console.info('删除');
    // console.info(this.status.currentDirNode);
    const dataId = this.status.currentDirNode.id;
    this.fileManageService.BatchRemove([dataId]).then((res: any) => {
      if (res.success) {
        this.message.success('删除成功');
        // if (deleteType === 1) {
        //   this.loadFloder();
        // } else {
        //   this.loadData();
        // }
        this.getNodesList();
        // 清空面包屑
        this.status.breadcrumbList = [{ name: '全部文件', id: '' }];
        this.status.locationNode = null;
        this.loadData();
        this.status.currentDirNode = null;
      } else {
        this.message.error(Utils.errorMessageProcessor(res));
      }

    });
    this.status.refreshstatus = true;

  }


  // 文件目录树部分结束********************************************************************************************************


}
